package com.webinsky.service.catalog.impl;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.webinsky.common.proj.DelFlag;
import com.webinsky.common.proj.Lang;
import com.webinsky.common.utils.db.Pagnation;
import com.webinsky.domain.catalog.Catalog;
import com.webinsky.domain.catalog.Catalogs;
import com.webinsky.persist.dao.catalog.TagMapper;
import com.webinsky.persist.dao.catalog.TagcatMapper;
import com.webinsky.persist.entity.catalog.Tag;
import com.webinsky.persist.entity.catalog.Tagcat;
import com.webinsky.persist.entity.catalog.TagcatFilter;
import com.webinsky.service.catalog.CatalogManagement;

@Service
public class CatalogManagementImpl implements CatalogManagement {
	@Autowired
	private TagcatMapper tagcatDao;
	@Autowired
	private TagMapper tagDao;
	
	private Tagcat convert(Catalog catalog){
		Tagcat tagcat = new Tagcat();
		tagcat.setLanguage(catalog.getLang().getLang());
		tagcat.setName(catalog.getName());
		tagcat.setSiteId(catalog.getSiteId());
		return tagcat;
	}
	
	private Catalog convert(Tagcat tagcat){
		Catalog c = new Catalog();
		c.setLang(Lang.parse(tagcat.getLanguage()));
		c.setName(tagcat.getName());
		c.setId(tagcat.getId());
		c.setSiteId(tagcat.getSiteId());
		return c;
	}
	
	@Override
	public void create(Catalog catalog) {
		if ( catalog != null ){
			Tagcat tagcat = convert(catalog);
			tagcat.setDel(DelFlag.UNDel.getFlag());
			int count = tagcatDao.selectCount();
			tagcat.setSort(count + 1);
			tagcatDao.insert(tagcat);
			catalog.setId(tagcat.getId());
		}
	}

	@Override
	public void updateName(int id, String name) {
		if ( id > 0 && name != null ){
			Tagcat tagcat = tagcatDao.selectById(id);
			if ( tagcat != null ){
				tagcat.setName(name);
				tagcatDao.updateByPrimaryKey(tagcat);
			}
		}
	}

	@Override
	public void delete(int id) {
		if ( id > 0 ){
			Tagcat tagcat = tagcatDao.selectById(id);
			if ( tagcat != null ){
				List<Tag> tags = tagDao.selectByTagcat(tagcat.getId());
				tags.forEach(tag -> {
					tag.setDel(DelFlag.Del.getFlag());
					tagDao.updateByPrimaryKey(tag);
				});
				tagcat.setDel(DelFlag.Del.getFlag());
				tagcatDao.updateByPrimaryKey(tagcat);
			}
		}
	}

	@Override
	public Catalogs getCatalogByPagnation(int start, int size) {
		Pagnation pagnation = new Pagnation();
		pagnation.setPageSize(size);
		pagnation.setPageStart(start);
		List<Tagcat> tagcats = tagcatDao.selectByPagnation(pagnation);
		if ( !tagcats.isEmpty() ){
			Catalogs catalogs = new Catalogs();
			int count = tagcatDao.selectCount();
			catalogs.setTotalSize(count);
			tagcats.forEach(v -> {
				if ( v.getDel() == DelFlag.UNDel.getFlag() ){
					catalogs.getCatalogs().add(convert(v));
				}
			});
			return catalogs;
		}
		return null;
	}

	@Override
	public Catalogs getCatalogByPagnation(int siteId, Lang lang,
			int start, int size) {
		if ( siteId > 0 && lang != null && start >= 0 && size > 0 ){
			TagcatFilter filter = new TagcatFilter();
			filter.setPageStart(start);
			filter.setPageSize(size);
			filter.setSiteId(siteId);
			filter.setLang(lang.getLang());
			List<Tagcat> tagcats = tagcatDao.selectByFilter(filter);
			if ( !tagcats.isEmpty() ){
				Catalogs catalogs = new Catalogs();
				int totalSize = tagcatDao.selectCountByFilter(filter);
				catalogs.setTotalSize(totalSize);
				tagcats.forEach(e -> catalogs.getCatalogs().add(convert(e)));
				return catalogs;
			}
		}
		return null;
	}

	@Override
	public void create(List<Catalog> catalogs) {
		if ( catalogs != null ) {
			catalogs.forEach( catalog -> create(catalog));
		}
	}

	@Override
	public void update(List<Catalog> catalogs) {
		if ( catalogs != null && !catalogs.isEmpty() ){
			List<Integer> ids = catalogs.stream().map(e -> e.getId()).collect(Collectors.toList());
			if ( !ids.isEmpty() ){
				List<Tagcat> tagcat = tagcatDao.selectByIds(ids);
				Map<Integer, String> catalogIdName = catalogs.stream().collect(Collectors.toMap(Catalog::getId, Catalog::getName));
				tagcat.forEach(e -> {
					if ( catalogIdName.get(e.getId()) != null ){
						e.setName(catalogIdName.get(e.getId()));
						e.setUpdated(new Date());
						tagcatDao.updateByPrimaryKey(e);
					}
				});
			}
		}
	}

	@Override
	public Catalogs getCatalogsByIds(int siteId, List<Integer> ids) {
		if ( siteId <= 0 || ids == null || ids.isEmpty() ){
			return null;
		}
		List<Tagcat> tagcats = tagcatDao.selectBySiteIdAndIds(siteId, ids);
		if ( tagcats.isEmpty() ){
			return null;
		}
		Catalogs c = new Catalogs();
		tagcats.forEach(e -> {
			c.getCatalogs().add(convert(e));
		});
		return c;
	}

	@Override
	public Catalogs getCatalogsByIds(List<Integer> ids) {
		if ( ids == null ){
			return null;
		}
		List<Tagcat> tagcats = tagcatDao.selectByIds(ids);
		if ( tagcats.isEmpty() ){
			return null;
		}
		Catalogs c = new Catalogs();
		tagcats.forEach(e -> {
			c.getCatalogs().add(convert(e));
		});
		return c;
	}
}
